COMMENT ⊗   VALID 00001 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 ENDMK
C⊗;
∂21-Jan-79  1528	BAK at MIT-MC (William A. Kornfeld) 	BYTE article 
Date: 21 JAN 1979 1829-EST
From: BAK at MIT-MC (William A. Kornfeld)
Subject: BYTE article
To: jra at SU-AI
CC: BAK at MIT-MC

What I had in mind for the article is the following:

Show how easy it is to use list structure to represent structured objects
in a database.  For example, in a database of student records:

(Courses (Smith John) (Fall 1977) (Calculus←1 Physics Philosophy))
(Courses (Jones Mary) (Spring 1978) (Category←Theory General←Relativity))
(Student-at (Smith John) MIT)
(Student-at (Jones Mary) Boston←University)

and show how easy it is to write a pattern matcher to allow you to allow
you to get records for John Smith for 1977 by using the pattern:
(Courses (Smith John) (? 1977) ?)

This could then lead into a discussion of deriving facts that are not 
explicitly stored, such as with the database:
(Mary mother←of Sam)
(Sam father←of Alice)

Who are the grandmothers of Alice?  and this becomes code something like:
(when (?man father←of Alice)
      (when (?woman mother←of ~man)
            (assert (grandmother Alice ~woman)))

This will show how patterned data objects can be manipulated.  After this 
should follow a discussion of pattern directed invocation of procedures.
Rather than the function call (GRANDMOTHERS Alice) which has to know all
the ways of deducing this from facts stored in the database, there is
a demons that have as pattern:
(when (find←all (grandmother =person))
     <...look for a father of person and then his mother ...>)

(when (find←all (grandmother =person))
      <...look for a mother of person and then her mother ...>)

(when (find←all (grandmother =person))
      <...look for an assertion of the form (grandchild ~person =the-grandmother)
           and return the-grandmother>)

and then broadcast (find←all (grandmother Alice)) to invoke all these procedures
simultaneously.

These would get across the basic concepts.  Other topics that could be developed
to a greater or lesser detail would be: [1] the kinds of AI programs that have 
been written using these kinds of systems and topics such as antecedent versus
consequent reasoning. [2]  The idea of "contexts" or having many
databases that form a tree with layering.[3]  How these assertions can be coded
much more efficiently in a discrimination net so that access time becomes
nearly independent of the size of the database.

These examples were thought up in the space of a few minutes and more 
interesting ones should be easy to find.  I think that the hairy macro 
characters could be done away with by using mixed upper/lower case or font
changes to make it more readable.

Questions I have:
1. How long should it be (and which of the above auxiliary topics do you think 
   should be developed the most)?

2. How much familiarity with Lisp should I assume on the part of the reader.
   Should I avoid the use of Lisp code?  Can I talk freely about recursion
   when describing the pattern matcher?  How about such topics as quoting or
   environments (such as would be returned by the pattern matcher) or avoid
   these issues totally?

I will be available to devote time to this starting in about a week.  It should
hopefully not take too long to write.

Concerning my master's thesis, right now I'm summarizing it in a paper for IJCAI
and I'll send you a copy of this as soon as it is completed.

Hope to get your comments on this soon.

						--Bill

∂03-Feb-79  1116	BAK at MIT-MC (William A. Kornfeld)
Date: 3 FEB 1979 1416-EST
From: BAK at MIT-MC (William A. Kornfeld)
To: jra at SU-AI

Hi.  Are you still interested in the article on pattern directed invocation?
I have time now to devote to it.  I would like to know when it has to be
done by and approximately how long it should be.

                                                     --Bill